home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 June / CHIP Haziran 2001.iso / prog / haziran / 19 / setup.exe / data.z / pci_diag.c < prev    next >
C/C++ Source or Header  |  2001-04-11  |  9KB  |  290 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - pci_diag.c
  3. //
  4. // This is a diagnostics application for accessing the PCI card.
  5. // Code was generated by WinDriver Wizard.
  6. // It accesses the hardware via WinDriver functions.
  7. // 
  8. ////////////////////////////////////////////////////////////////
  9.  
  10. #include "pci_lib.h"
  11. #include "../shared/pci_diag_lib.h"
  12. #include <stdio.h>
  13.  
  14. // input of command from user
  15. static char line[256];
  16.  
  17. char *PCI_GetAddrSpaceName(PCI_ADDR addrSpace)
  18. {
  19.     return 
  20.         addrSpace==PCI_AD_BAR0 ? "Addr Space BAR0" :
  21.         addrSpace==PCI_AD_BAR1 ? "Addr Space BAR1" :
  22.         addrSpace==PCI_AD_BAR2 ? "Addr Space BAR2" :
  23.         addrSpace==PCI_AD_BAR3 ? "Addr Space BAR3" :
  24.         addrSpace==PCI_AD_BAR4 ? "Addr Space BAR4" :
  25.         addrSpace==PCI_AD_BAR5 ? "Addr Space BAR5" :
  26.         addrSpace==PCI_AD_EPROM ? "EEPROM Addr Space" :
  27.         "Invalid";
  28. }
  29.  
  30. void PCI_AccessRanges(PCI_HANDLE hPCI)
  31. {
  32.     int cmd, cmd2, i;
  33.     DWORD addr, data;
  34.     PCI_ADDR ad_sp = 0;
  35.     PCI_MODE ad_mode = PCI_MODE_DWORD;
  36.  
  37.     for (; ad_sp<PCI_ITEMS && !PCI_IsAddrSpaceActive(hPCI, ad_sp); ad_sp++)
  38.     if (ad_sp==PCI_ITEMS)
  39.     {
  40.         printf ("No active memory or IO ranges on board!\n");
  41.         return;
  42.     }
  43.  
  44.     do
  45.     {
  46.         printf ("Access the board's memory and IO ranges\n");
  47.         printf ("---------------------------------------\n");
  48.         printf ("1. Change active memory space: %s\n",PCI_GetAddrSpaceName(ad_sp));
  49.         printf ("2. Toggle active mode: %s\n", 
  50.             ad_mode==PCI_MODE_BYTE ? "BYTE (8 bit)" :
  51.             ad_mode==PCI_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  52.         printf ("3. Read from board\n");
  53.         printf ("4. Write to board\n");
  54.         printf ("99. Back to main menu\n");
  55.         printf ("\n");
  56.         printf ("Enter option: ");
  57.         cmd = 0;
  58.         fgets(line, sizeof(line), stdin);
  59.         sscanf(line, "%d",&cmd);
  60.         switch (cmd)
  61.         {
  62.         case 1:
  63.             printf ("Choose memory or IO space:\n");
  64.             printf ("--------------------------\n");
  65.             for (i=0; i<PCI_ITEMS; i++)
  66.             {
  67.                 printf ("%d. %s\n", i+1, PCI_GetAddrSpaceName(i));
  68.                 if (!PCI_IsAddrSpaceActive(hPCI, i))
  69.                     printf (" - space not active\n");
  70.             }
  71.             printf ("Enter option: ");
  72.             cmd2 = 99;
  73.             fgets(line, sizeof(line), stdin);
  74.             sscanf(line, "%d",&cmd2);
  75.             if (cmd2>=1 && cmd2<PCI_ITEMS+1)
  76.             {
  77.                 ad_sp = cmd2-1;
  78.                 if (!PCI_IsAddrSpaceActive(hPCI, ad_sp))
  79.                     printf ("Chosen space not active!\n");
  80.             }
  81.             break;
  82.         case 2:
  83.             ad_mode = (ad_mode + 1) % 3;
  84.             break;
  85.         case 3:
  86.             printf ("Enter offset to read from: ");
  87.             fgets(line, sizeof(line), stdin);
  88.             sscanf (line, "%x", &addr);
  89.             switch (ad_mode)
  90.             {
  91.             case PCI_MODE_BYTE:
  92.                 data = PCI_ReadByte(hPCI, ad_sp, addr);
  93.                 break;
  94.             case PCI_MODE_WORD:
  95.                 data = PCI_ReadWord(hPCI, ad_sp, addr);
  96.                 break;
  97.             case PCI_MODE_DWORD:
  98.                 data = PCI_ReadDword(hPCI, ad_sp, addr);
  99.                 break;
  100.             }
  101.             printf ("Value read: %x\n", data);
  102.             break;
  103.         case 4:
  104.             printf ("Enter offset to write to: ");
  105.             fgets(line, sizeof(line), stdin);
  106.             sscanf (line,"%x", &addr);
  107.             printf ("Enter data to write %s: ",
  108.                 ad_mode==PCI_MODE_BYTE ? "BYTE (8 bit)" :
  109.                 ad_mode==PCI_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  110.             fgets(line, sizeof(line), stdin);
  111.             sscanf (line, "%x",&data);
  112.             switch (ad_mode)
  113.             {
  114.             case PCI_MODE_BYTE:
  115.                 PCI_WriteByte(hPCI, ad_sp, addr, (BYTE) data);
  116.                 break;
  117.             case PCI_MODE_WORD:
  118.                 PCI_WriteWord(hPCI, ad_sp, addr, (WORD) data);
  119.                 break;
  120.             case PCI_MODE_DWORD:
  121.                 PCI_WriteDword(hPCI, ad_sp, addr, data);
  122.                 break;
  123.             }
  124.             break;
  125.         }
  126.     } while (cmd!=99);
  127. }
  128.  
  129. void WINAPI PCI_IntHandlerRoutine(PCI_HANDLE hPCI, PCI_INT_RESULT *intResult)
  130. {
  131.     printf ("Got Int number %d\n", intResult->dwCounter);
  132. }
  133.  
  134. void PCI_EnableDisableInterrupts(PCI_HANDLE hPCI)
  135. {
  136.     int cmd;
  137.  
  138.     printf ("WARNING!!!\n");
  139.     printf ("----------\n");
  140.     printf ("Your hardware has level sensitive interrupts.\n");
  141.     printf ("You must modify the source code of PCI_IntEnable(), in the file pci_lib.c,\n");
  142.     printf ("to acknowledge the interrupt before enabling interrupts.\n");
  143.     printf ("Without this modification, your PC will HANG upon interrupt!\n");
  144.     printf ("\n");
  145.  
  146.     do
  147.     {
  148.         printf ("Enable / Disable interrupts\n");
  149.         printf ("---------------------------\n");
  150.         printf ("1. %s Int\n", PCI_IntIsEnabled(hPCI) ? "Disable" : "Enable");
  151.         printf ("99. Back to main menu\n");
  152.         printf ("\n");
  153.         printf ("Enter option: ");
  154.         cmd = 0;
  155.         fgets(line, sizeof(line), stdin);
  156.         sscanf(line, "%d",&cmd);
  157.         switch (cmd)
  158.         {
  159.         case 1:
  160.             if (PCI_IntIsEnabled(hPCI))
  161.             {
  162.                 printf ("Disabling interrupt Int\n");
  163.                 PCI_IntDisable(hPCI);
  164.             }
  165.             else
  166.             {
  167.                 printf ("Enabling interrupt Int\n");
  168.                 if (!PCI_IntEnable(hPCI, PCI_IntHandlerRoutine))
  169.                     printf ("failed enabling interrupt Int\n");
  170.             }
  171.             break;
  172.         }
  173.     } while (cmd!=99);
  174. }
  175.  
  176. PCI_HANDLE PCI_LocateAndOpenBoard(DWORD dwVendorID, DWORD dwDeviceID, BOOL fUseInt)
  177. {
  178.     DWORD cards, my_card;
  179.     PCI_HANDLE hPCI = NULL;
  180.  
  181.     if (dwVendorID==0)
  182.     {
  183.         printf ("Enter VendorID: ");
  184.         fgets(line, sizeof(line), stdin);
  185.         sscanf (line, "%x",&dwVendorID);
  186.         if (dwVendorID==0) return NULL;
  187.  
  188.         printf ("Enter DeviceID: ");
  189.         fgets(line, sizeof(line), stdin);
  190.         sscanf (line, "%x",&dwDeviceID);
  191.     }
  192.     cards = PCI_CountCards (dwVendorID, dwDeviceID);
  193.     if (cards==0)
  194.     {
  195.         printf("%s", PCI_ErrorString);
  196.         return NULL;
  197.     }
  198.     else if (cards==1) my_card = 1;
  199.     else
  200.     {
  201.         DWORD i;
  202.  
  203.         printf("Found %d matching PCI cards\n", cards);
  204.         printf("Select card (1-%d): ", cards);
  205.         i = 0;
  206.         fgets(line, sizeof(line), stdin);
  207.         sscanf (line, "%d",&i);
  208.         if (i>=1 && i <=cards) my_card = i;
  209.         else 
  210.         {
  211.             printf ("Choice out of range\n");
  212.             return NULL;
  213.         }
  214.     }
  215.     if (PCI_Open (&hPCI, dwVendorID, dwDeviceID, my_card - 1, fUseInt ? PCI_OPEN_USE_INT : 0 ))
  216.         printf ("PCI card found!\n");
  217.     else printf ("%s", PCI_ErrorString);
  218.     return hPCI;
  219. }
  220.  
  221. int main(int argc, char *argv[])
  222. {
  223.     int cmd;
  224.     PCI_HANDLE hPCI = NULL;
  225.     HANDLE hWD;
  226.     BOOL fUseInt = FALSE; // by default - do not install interrupts
  227.  
  228.     printf ("PCI diagnostic utility.\n");
  229.     printf ("Application accesses hardware using " WD_PROD_NAME ".\n");
  230.  
  231.     // make sure WinDriver is loaded
  232.     if (!PCI_Get_WD_handle(&hWD)) 
  233.         return 0;
  234.     WD_Close (hWD);
  235.  
  236.     if (PCI_DEFAULT_VENDOR_ID)
  237.         hPCI = PCI_LocateAndOpenBoard(PCI_DEFAULT_VENDOR_ID, PCI_DEFAULT_DEVICE_ID, fUseInt);
  238.  
  239.     do
  240.     {
  241.         printf ("\n");
  242.         printf ("PCI main menu\n");
  243.         printf ("-------------------\n");
  244.         printf ("1. Scan PCI bus\n");
  245.         printf ("2. Set opening board %s interrupts\n", fUseInt ? "without" : "with");
  246.         printf ("3. Locate/Choose PCI board (%s interrupts)\n", fUseInt ? "with" : "without");
  247.         if (hPCI)
  248.         {
  249.             printf ("4. PCI configuration registers\n");
  250.             printf ("6. Access PCI memory and IO ranges\n");
  251.             if (hPCI->fUseInt)
  252.                 printf ("7. Enable / Disable interrupts\n");
  253.         }
  254.         printf ("99. Exit\n");
  255.         printf ("Enter option: ");
  256.         cmd = 0;
  257.         fgets(line, sizeof(line), stdin);
  258.         sscanf(line, "%d",&cmd);
  259.         switch (cmd)
  260.         {
  261.         case 1: // Scan PCI bus
  262.             PCI_Print_all_cards_info();
  263.             break;
  264.         case 2: // Set opening board with / without interrupts
  265.             fUseInt = !fUseInt;
  266.             break;
  267.         case 3: // Locate PCI board
  268.             if (hPCI) PCI_Close(hPCI);
  269.             hPCI = PCI_LocateAndOpenBoard(0, 0, fUseInt);
  270.             if (!hPCI) printf ("PCI card open failed!\n");
  271.             break;
  272.         case 4: // PCI configuration registers
  273.             if (hPCI) PCI_EditConfigReg(hPCI->pciSlot);
  274.             break;
  275.         case 6: // Access PCI memory and IO ranges
  276.             if (hPCI) PCI_AccessRanges(hPCI);
  277.             break;
  278.         case 7: // Enable / Disable interrupts
  279.             if (hPCI && hPCI->fUseInt)
  280.                 PCI_EnableDisableInterrupts(hPCI);
  281.             break;
  282.         }
  283.     } while (cmd!=99);
  284.  
  285.     if (hPCI) PCI_Close(hPCI);
  286.  
  287.     return 0;
  288. }
  289.  
  290.